export type Endpoint = {
    title?: string;
    description?: string;
    path: string;
    method: HttpMethod;
    servers?: Server[];
    request: RequestSchema;
    response: ResponseSchema;
    deprecated: boolean;
};
export type Server = {
    url: string;
    description?: string;
    variables?: {
        [variableName: string]: ServerVariableSchema;
    };
};
export type ServerVariableSchema = ServerVariableStringSchema | ServerVariableStringEnumSchema;
export type ServerVariableStringSchema = {
    type: 'string';
    default: string;
    description?: string;
};
export type ServerVariableStringEnumSchema = {
    type: 'enum<string>';
    enum: string[];
    default: string;
    description?: string;
};
export declare const httpMethods: readonly ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
export type HttpMethod = (typeof httpMethods)[number];
export type RequestSchema = {
    security: SecurityOption[];
    parameters: ParameterSections;
    body: BodySchema;
    codeSamples?: CodeSample[];
};
export type CodeSample = {
    label?: string;
    lang: string;
    source: string;
};
export type BodySchema = {
    [contentType: string]: ContentSchema;
};
export type ContentSchema = {
    schemaArray: DataSchemaArray;
    examples: {
        [title: string]: ExampleSchema;
    };
};
export type ExampleSchema = {
    summary?: string;
    description?: string;
    value: unknown;
};
export type ParameterSchema = {
    schema: DataSchemaArray;
};
export type ParameterGroup = {
    [name: string]: ParameterSchema;
};
export type ParameterLocation = 'query' | 'header' | 'cookie' | 'path';
type NonPathParameterLocation = Exclude<ParameterLocation, 'path'>;
export type ParameterSections = Record<ParameterLocation, ParameterGroup>;
export type SecurityOption = {
    title: string;
    parameters: SecurityParameterSections;
};
type ApiKeyParameterSchema = {
    type: 'apiKey';
    description?: string;
};
type HttpParameterSchema = {
    type: 'http';
    scheme: 'bearer' | 'basic';
    description?: string;
};
type OAuth2ParameterSchema = {
    type: 'oauth2';
    description?: string;
};
export type SecurityParameterSchema = ApiKeyParameterSchema | HttpParameterSchema | OAuth2ParameterSchema;
export type SecurityParameterGroup = {
    [name: string]: SecurityParameterSchema;
};
export type SecurityParameterSections = Record<NonPathParameterLocation, SecurityParameterGroup>;
export type ResponseSchema = {
    [code: string]: BodySchema;
};
export type DataSchemaArray = [DataSchema, ...DataSchema[]];
export declare const typeList: readonly ["boolean", "string", "number", "integer", "object", "array", "enum<string>", "enum<number>", "enum<integer>", "file", "null", "any"];
export type SchemaType = (typeof typeList)[number];
export type DataSchema = BooleanSchema | StringSchema | NumberSchema | ObjectSchema | ArraySchema | StringEnumSchema | NumberEnumSchema | FileSchema | NullSchema | AnySchema;
export type BaseSchema<T> = {
    type: SchemaType;
    title?: string;
    description?: string;
    default?: T;
    example?: T;
    required?: boolean;
    readOnly?: boolean;
    writeOnly?: boolean;
    deprecated?: boolean;
};
export type BooleanSchema = {
    type: 'boolean';
} & BaseSchema<boolean>;
export type StringSchema = {
    type: 'string';
    format?: string;
    pattern?: string;
    maxLength?: number;
    minLength?: number;
} & BaseSchema<string>;
export type NumberSchema = {
    type: 'number' | 'integer';
    multipleOf?: number;
    maximum?: number;
    exclusiveMaximum?: boolean;
    minimum?: number;
    exclusiveMinimum?: boolean;
} & BaseSchema<number>;
export type ObjectSchema = {
    type: 'object';
    additionalProperties?: boolean | DataSchemaArray;
    maxProperties?: number;
    minProperties?: number;
    properties: {
        [key: string]: DataSchemaArray;
    };
} & BaseSchema<Record<string, unknown>>;
export type ArraySchema = {
    type: 'array';
    items: DataSchemaArray;
    maxItems?: number;
    minItems?: number;
    uniqueItems?: boolean;
} & BaseSchema<unknown[]>;
export type StringEnumSchema = {
    type: 'enum<string>';
    enum: string[];
} & BaseSchema<string>;
export type NumberEnumSchema = {
    type: 'enum<number>' | 'enum<integer>';
    enum: number[];
} & BaseSchema<number>;
export type FileSchema = {
    type: 'file';
    contentEncoding?: string;
    contentMediaType?: string;
} & BaseSchema<File>;
export type NullSchema = {
    type: 'null';
} & BaseSchema<null>;
export type AnySchema = {
    type: 'any';
} & BaseSchema<unknown>;
export {};
